package com.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;

import com.utils.ValidatorUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.annotation.IgnoreAuth;

import com.entity.YonghuEntity;
import com.entity.view.YonghuView;

import com.service.YonghuService;
import com.service.TokenService;
import com.utils.PageUtils;
import com.utils.R;
import com.utils.MD5Util;
import com.utils.MPUtil;
import com.utils.CommonUtil;
import java.io.IOException;

/**
 * 用户
 * 后端接口
 *
 * author: team10
 * @email
 *
 */
@RestController
@RequestMapping("/yonghu")
public class YonghuController {
	@Autowired
	private YonghuService yonghuService;

	@Autowired
	private TokenService tokenService;

	/**
	 * 用户登录接口
	 * @param username 用户名
	 * @param password 密码
	 * @param captcha 验证码
	 * @param request Http请求
	 * @return 登录结果
	 */
	@IgnoreAuth
	@RequestMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		YonghuEntity user = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
		if(user==null || !user.getMima().equals(password)) {
			return R.error("账号或密码不正确");
		}

		String token = tokenService.generateToken(user.getId(), username,"yonghu",  "用户" );
		return R.ok().put("token", token);
	}

	/**
	 * 用户注册接口
	 * @param yonghu 用户实体
	 * @return 注册结果
	 */
	@IgnoreAuth
	@RequestMapping("/register")
	public R register(@RequestBody YonghuEntity yonghu){
		//ValidatorUtils.validateEntity(yonghu);
		YonghuEntity user = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
		if(user!=null) {
			return R.error("注册用户已存在");
		}
		Long uId = new Date().getTime();
		yonghu.setId(uId);
		yonghuService.insert(yonghu);
		return R.ok();
	}

	/**
	 * 用户退出登录
	 * @param request Http请求
	 * @return 退出结果
	 */
	@RequestMapping("/logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}

	/**
	 * 获取当前用户信息（session用户信息）
	 * @param request Http请求
	 * @return 当前用户信息
	 */
	@RequestMapping("/session")
	public R getCurrUser(HttpServletRequest request){
		Long id = (Long)request.getSession().getAttribute("userId");
		YonghuEntity user = yonghuService.selectById(id);
		return R.ok().put("data", user);
	}

	/**
	 * 密码重置接口
	 * @param username 用户名
	 * @param request Http请求
	 * @return 重置结果
	 */
	@IgnoreAuth
	@RequestMapping(value = "/resetPass")
	public R resetPass(String username, HttpServletRequest request){
		YonghuEntity user = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
		if(user==null) {
			return R.error("账号不存在");
		}
		user.setMima("123456");
		yonghuService.updateById(user);
		return R.ok("密码已重置为：123456");
	}


	/**
	 * 后端用户列表分页查询接口
	 * @param params 查询参数
	 * @param yonghu 用户实体
	 * @param request Http请求
	 * @return 用户列表
	 */
	@RequestMapping("/page")
	public R page(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
				  HttpServletRequest request){
		EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
		PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));

		return R.ok().put("data", page);
	}

	/**
	 * 前端用户列表查询接口
	 * @param params 查询参数
	 * @param yonghu 用户实体
	 * @param request Http请求
	 * @return 用户列表
	 */
	@IgnoreAuth
	@RequestMapping("/list")
	public R list(@RequestParam Map<String, Object> params,YonghuEntity yonghu,
				  HttpServletRequest request){
		EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
		PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
		return R.ok().put("data", page);
	}

	/**
	 * 获取所有用户列表
	 * @param yonghu 用户实体
	 * @return 用户列表
	 */
	@RequestMapping("/lists")
	public R list( YonghuEntity yonghu){
		EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
		ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
		return R.ok().put("data", yonghuService.selectListView(ew));
	}

	/**
	 * 查询单个用户信息
	 * @param yonghu 用户实体
	 * @return 用户信息
	 */
	@RequestMapping("/query")
	public R query(YonghuEntity yonghu){
		EntityWrapper< YonghuEntity> ew = new EntityWrapper< YonghuEntity>();
		ew.allEq(MPUtil.allEQMapPre( yonghu, "yonghu"));
		YonghuView yonghuView =  yonghuService.selectView(ew);
		return R.ok("查询用户成功").put("data", yonghuView);
	}

	/**
	 * 后端查询用户详情
	 * @param id 用户ID
	 * @return 用户详情
	 */
	@RequestMapping("/info/{id}")
	public R info(@PathVariable("id") Long id){
		YonghuEntity yonghu = yonghuService.selectById(id);
		return R.ok().put("data", yonghu);
	}

	/**
	 * 前端查询用户详情
	 * @param id 用户ID
	 * @return 用户详情
	 */
	@IgnoreAuth
	@RequestMapping("/detail/{id}")
	public R detail(@PathVariable("id") Long id){
		YonghuEntity yonghu = yonghuService.selectById(id);
		return R.ok().put("data", yonghu);
	}

	/**
	 * 后端保存用户信息
	 * @param yonghu 用户实体
	 * @param request Http请求
	 * @return 保存结果
	 */
	@RequestMapping("/save")
	public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
		yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
		//ValidatorUtils.validateEntity(yonghu);
		YonghuEntity user = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		yonghu.setId(new Date().getTime());
		yonghuService.insert(yonghu);
		return R.ok();
	}

	/**
	 * 前端保存用户信息
	 * @param yonghu 用户实体
	 * @param request Http请求
	 * @return 保存结果
	 */
	@RequestMapping("/add")
	public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
		yonghu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
		//ValidatorUtils.validateEntity(yonghu);
		YonghuEntity user = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
		if(user!=null) {
			return R.error("用户已存在");
		}
		yonghu.setId(new Date().getTime());
		yonghuService.insert(yonghu);
		return R.ok();
	}

	/**
	 * 更新用户信息
	 * @param yonghu 用户实体
	 * @param request Http请求
	 * @return 更新结果
	 */
	@RequestMapping("/update")
	public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
		yonghuService.updateById(yonghu);
		return R.ok();
	}

	/**
	 * 删除用户
	 * @param id 用户ID
	 * @return 删除结果
	 */
	@RequestMapping("/delete")
	public R delete(@RequestBody Long[] id){
		yonghuService.deleteBatchIds(Arrays.asList(id));
		return R.ok();
	}
}
